home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / convrtrs / pbmplus / update4.lha / src / extra / ppmtomitsu.c.diff < prev    next >
Encoding:
Text File  |  1993-07-08  |  11.1 KB  |  337 lines
  1. *** ppmtomitsu.c.orig    Wed Mar 31 12:24:24 1993
  2. --- ppmtomitsu.c    Thu Jul 08 19:48:53 1993
  3. ***************
  4. *** 3,8 ****
  5. --- 3,13 ----
  6.   **                (or the S3410-30 parallel interface)
  7.   **
  8.   ** Copyright (C) 1992,93 by S.Petra Zeidler
  9. + ** Minor modifications by Ingo Wilken:
  10. + **  - moved large arrays off the stack into globals (A_SMALLSTACK)
  11. + **  - mymalloc() and check_and_rotate() functions for often used
  12. + **    code fragments.  Reduces code size by a few KB.
  13. + **  - use pm_error() instead of fprints(stderr)
  14.   **
  15.   ** This software was written for the Max Planck Institut fuer Radioastronomie,
  16.   ** Bonn, Germany, Optical Interferometry group
  17. ***************
  18. *** 19,27 ****
  19. --- 24,41 ----
  20.   #include "ppm.h"
  21.   #include "ppmcmap.h"
  22.   #include "pbmplus.h"
  23. + #ifdef __STDC__
  24. + #include <stdlib.h>
  25. + #else
  26.   #include <memory.h>
  27. + #endif
  28.   #include "mitsu.h"
  29.   
  30. + #ifdef A_SMALLSTACK
  31. + hashinfo colorhashtable[HASHSIZE];
  32. + #endif
  33. + 
  34. + 
  35.   #ifdef __STDC__
  36.   void main(int argc, char *argv[] )
  37.   #else
  38. ***************
  39. *** 31,37 ****
  40. --- 45,53 ----
  41.   #endif
  42.       {
  43.       FILE             *ifp;
  44. + #ifndef A_SMALLSTACK
  45.       hashinfo         colorhashtable[HASHSIZE];
  46. + #endif
  47.       struct hashinfo  *hashrun;
  48.       pixel            *xP;
  49.       int              argn;
  50. ***************
  51. *** 70,76 ****
  52.           }
  53.       else if (pm_keymatch(argv[argn], "-media", 2)) {
  54.           ++argn;
  55. !         if (argn == argc || sscanf(argv[argn], "%s", media) < 1)
  56.               pm_usage(usage);
  57.           else if (mytoupper(media[0]) != 'A')
  58.               pm_usage(usage);
  59. --- 86,92 ----
  60.           }
  61.       else if (pm_keymatch(argv[argn], "-media", 2)) {
  62.           ++argn;
  63. !         if (argn == argc || sscanf(argv[argn], "%15s", media) < 1)
  64.               pm_usage(usage);
  65.           else if (mytoupper(media[0]) != 'A')
  66.               pm_usage(usage);
  67. ***************
  68. *** 130,147 ****
  69.   
  70.           ppm_readppminit(ifp, &cols, &rows, &maxval, &format);
  71.           pixelrow = (pixel *) ppm_allocrow(cols);
  72. !         if ((redrow = malloc(cols * sizeof(char))) == NULL) {
  73. !             fprintf(stderr, "ppmtomitsu: malloc failed, exiting\n");
  74. !             exit(1);
  75. !         }
  76. !         if ((greenrow = malloc( cols * sizeof(char))) == NULL) {
  77. !             fprintf(stderr, "ppmtomitsu: malloc failed, exiting\n");
  78. !             exit(1);
  79. !         }
  80. !         if ((bluerow = malloc( cols * sizeof(char))) == NULL) {
  81. !             fprintf(stderr, "ppmtomitsu: malloc failed, exiting\n");
  82. !             exit(1);
  83. !         }
  84.           lineputinit(cols, rows, sharpness, enlarge, copy, medias);
  85.   
  86.           for ( row = 0; row < rows; ++row ) {
  87. --- 146,154 ----
  88.   
  89.           ppm_readppminit(ifp, &cols, &rows, &maxval, &format);
  90.           pixelrow = (pixel *) ppm_allocrow(cols);
  91. !         redrow = mymalloc(cols * sizeof(char));
  92. !         greenrow = mymalloc(cols * sizeof(char));
  93. !         bluerow = mymalloc(cols * sizeof(char));
  94.           lineputinit(cols, rows, sharpness, enlarge, copy, medias);
  95.   
  96.           for ( row = 0; row < rows; ++row ) {
  97. ***************
  98. *** 215,227 ****
  99.                       else {
  100.                           while (hashrun->next != NULL)
  101.                               hashrun = hashrun->next;
  102. !                         if ((hashrun->next = 
  103. !                         (struct hashinfo *) malloc(sizeof(struct hashinfo)))
  104. !                                                                 == NULL) {
  105. !                             fprintf(stderr, "%s: malloc failed, exiting\n",
  106. !                                 argv[0]);
  107. !                             exit(2);
  108. !                         }
  109.                           hashrun = hashrun->next;
  110.                           hashrun->color = (table[colval]).color;
  111.                           hashrun->flag  = colval;
  112. --- 222,229 ----
  113.                       else {
  114.                           while (hashrun->next != NULL)
  115.                               hashrun = hashrun->next;
  116. !                         hashrun->next =
  117. !                             (struct hashinfo *) mymalloc(sizeof(struct hashinfo));
  118.                           hashrun = hashrun->next;
  119.                           hashrun->color = (table[colval]).color;
  120.                           hashrun->flag  = colval;
  121. ***************
  122. *** 246,258 ****
  123.                       else {
  124.                           while (hashrun->next != NULL)
  125.                               hashrun = hashrun->next;
  126. !                         if ((hashrun->next = 
  127. !                         (struct hashinfo *) malloc(sizeof(struct hashinfo)))
  128. !                                                                 == NULL) {
  129. !                             fprintf(stderr, "%s: malloc failed, exiting\n",
  130. !                                 argv[0]);
  131. !                             exit(2);
  132. !                         }
  133.                           hashrun = hashrun->next;
  134.                           hashrun->color = (table[colval]).color;
  135.                           hashrun->flag  = colval;
  136. --- 248,255 ----
  137.                       else {
  138.                           while (hashrun->next != NULL)
  139.                               hashrun = hashrun->next;
  140. !                         hashrun->next =
  141. !                             (struct hashinfo *) mymalloc(sizeof(struct hashinfo));
  142.                           hashrun = hashrun->next;
  143.                           hashrun->color = (table[colval]).color;
  144.                           hashrun->flag  = colval;
  145. ***************
  146. *** 269,277 ****
  147.                           if (hashrun->next != NULL)
  148.                               hashrun = hashrun->next;
  149.                           else {
  150. !                             fprintf(stderr, "%s: you just found a letal bug.\n",
  151. !                                 argv[0]);
  152. !                             exit(1);
  153.                           }
  154.                       datum(hashrun->flag);
  155.                   }
  156. --- 266,272 ----
  157.                           if (hashrun->next != NULL)
  158.                               hashrun = hashrun->next;
  159.                           else {
  160. !                             pm_error("you just found a lethal bug.");
  161.                           }
  162.                       datum(hashrun->flag);
  163.                   }
  164. ***************
  165. *** 395,425 ****
  166.       default:
  167.           SHARPNESS(SP_USER);
  168.       }
  169. !     if (cols > rows) {
  170. !         ROTATEIMG(DOROTATE);                        /* rotate image */
  171. !         if (enlarge*rows > medias.maxcols || enlarge*cols > medias.maxrows) {
  172. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  173. !                           , medias.maxrows, medias.maxcols);
  174. !             exit(1);
  175. !         }
  176. !         HPIXELS(cols);
  177. !         VPIXELS(rows);
  178. !         HPIXELSOFF((medias.maxcols/enlarge - rows)/2);
  179. !         VPIXELSOFF((medias.maxrows/enlarge - cols)/2);
  180. !         pm_message("rotating image for output");
  181. !     }
  182. !     else {
  183. !         ROTATEIMG(DONTROTATE);
  184. !         if (enlarge*rows > medias.maxrows || enlarge*cols > medias.maxcols) {
  185. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  186. !                           , medias.maxrows, medias.maxcols);
  187. !             exit(1);
  188. !         }
  189. !         HPIXELS(cols);
  190. !         VPIXELS(rows);
  191. !         HPIXELSOFF((medias.maxcols/enlarge - cols)/2);
  192. !         VPIXELSOFF((medias.maxrows/enlarge - rows)/2);
  193. !     }
  194.       DATASTART;
  195.       return;
  196.   }
  197. --- 390,396 ----
  198.       default:
  199.           SHARPNESS(SP_USER);
  200.       }
  201. !     check_and_rotate(cols, rows, enlarge, medias);
  202.       DATASTART;
  203.       return;
  204.   }
  205. ***************
  206. *** 495,525 ****
  207.   #endif /*__STDC__*/
  208.   {
  209.       DONELOOKUPTABLE;
  210. !     if (cols > rows) {
  211. !         ROTATEIMG(DOROTATE);                        /* rotate image */
  212. !         if (enlarge*rows > medias.maxcols || enlarge*cols > medias.maxrows) {
  213. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  214. !                           , medias.maxrows, medias.maxcols);
  215. !             exit(1);
  216. !         }
  217. !         HPIXELS(cols);
  218. !         VPIXELS(rows);
  219. !         HPIXELSOFF((medias.maxcols/enlarge - rows)/2);
  220. !         VPIXELSOFF((medias.maxrows/enlarge - cols)/2);
  221. !         pm_message("rotating image for output");
  222. !     }
  223. !     else {
  224. !         ROTATEIMG(DONTROTATE);
  225. !         if (enlarge*rows > medias.maxrows || enlarge*cols > medias.maxcols) {
  226. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  227. !                           , medias.maxrows, medias.maxcols);
  228. !             exit(1);
  229. !         }
  230. !         HPIXELS(cols);
  231. !         VPIXELS(rows);
  232. !         HPIXELSOFF((medias.maxcols/enlarge - cols)/2);
  233. !         VPIXELSOFF((medias.maxrows/enlarge - rows)/2);
  234. !     }
  235.       DATASTART;
  236.       return;
  237.   }
  238. --- 466,472 ----
  239.   #endif /*__STDC__*/
  240.   {
  241.       DONELOOKUPTABLE;
  242. !     check_and_rotate(cols, rows, enlarge, medias);
  243.       DATASTART;
  244.       return;
  245.   }
  246. ***************
  247. *** 583,594 ****
  248.       default:
  249.           SHARPNESS(SP_USER);
  250.       }
  251.       if (cols > rows) {
  252.           ROTATEIMG(DOROTATE);                        /* rotate image */
  253.           if (enlarge*rows > medias.maxcols || enlarge*cols > medias.maxrows) {
  254. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  255. !                           , medias.maxrows, medias.maxcols);
  256. !             exit(1);
  257.           }
  258.           HPIXELS(cols);
  259.           VPIXELS(rows);
  260. --- 530,573 ----
  261.       default:
  262.           SHARPNESS(SP_USER);
  263.       }
  264. +     check_and_rotate(cols, rows, enlarge, medias);
  265. +     return;
  266. + }
  267. + 
  268. + 
  269. + #ifdef __STDC__
  270. + static void *
  271. + mymalloc(long bytes)
  272. + #else
  273. + static char *
  274. + mymalloc(bytes)
  275. +     long bytes;
  276. + #endif
  277. + {
  278. +     void *mem;
  279. + 
  280. +     mem = malloc(bytes);
  281. +     if( mem == NULL )
  282. +         pm_error("out of memory allocating %d bytes", bytes);
  283. + 
  284. +     return mem;
  285. + }
  286. + 
  287. + 
  288. + #ifdef __STDC__
  289. + static void
  290. + check_and_rotate(int cols, int rows, int enlarge, struct mediasize medias)
  291. + #else
  292. + static void
  293. + check_and_rotate(cols, rows, enlarge, medias)
  294. +     int cols, rows, enlarge;
  295. +     struct mediasize medias;
  296. + #endif
  297. + {
  298.       if (cols > rows) {
  299.           ROTATEIMG(DOROTATE);                        /* rotate image */
  300.           if (enlarge*rows > medias.maxcols || enlarge*cols > medias.maxrows) {
  301. !             pm_error("Image too large, MaxPixels = %d x %d", medias.maxrows, medias.maxcols);
  302.           }
  303.           HPIXELS(cols);
  304.           VPIXELS(rows);
  305. ***************
  306. *** 599,607 ****
  307.       else {
  308.           ROTATEIMG(DONTROTATE);
  309.           if (enlarge*rows > medias.maxrows || enlarge*cols > medias.maxcols) {
  310. !             fprintf(stderr, "ppmtomitsu: Image too large, MaxPixels = %d x %d\n"
  311. !                           , medias.maxrows, medias.maxcols);
  312. !             exit(1);
  313.           }
  314.           HPIXELS(cols);
  315.           VPIXELS(rows);
  316. --- 578,584 ----
  317.       else {
  318.           ROTATEIMG(DONTROTATE);
  319.           if (enlarge*rows > medias.maxrows || enlarge*cols > medias.maxcols) {
  320. !             pm_error("Image too large, MaxPixels = %d x %d", medias.maxrows, medias.maxcols);
  321.           }
  322.           HPIXELS(cols);
  323.           VPIXELS(rows);
  324. ***************
  325. *** 608,612 ****
  326.           HPIXELSOFF((medias.maxcols/enlarge - cols)/2);
  327.           VPIXELSOFF((medias.maxrows/enlarge - rows)/2);
  328.       }
  329. -     return;
  330.   }
  331. --- 585,589 ----
  332.           HPIXELSOFF((medias.maxcols/enlarge - cols)/2);
  333.           VPIXELSOFF((medias.maxrows/enlarge - rows)/2);
  334.       }
  335.   }
  336. + 
  337.